using System;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("TouchList")]
	public class TouchList : PegUIElement
	{
		public enum Orientation
		{
			Horizontal,
			Vertical
		}

		public enum Alignment
		{
			Min,
			Mid,
			Max
		}

		public enum LayoutPlane
		{
			XY,
			XZ
		}

		[Attribute38("TouchList.ItemInfo")]
		public class ItemInfo : MonoClass
		{
			public Vector3 Size => method_11<Vector3>("get_Size", Array.Empty<object>());

			public Vector3 Offset => method_11<Vector3>("get_Offset", Array.Empty<object>());

			public int LongListIndex => method_11<int>("get_LongListIndex", Array.Empty<object>());

			public Vector3 Min => method_11<Vector3>("get_Min", Array.Empty<object>());

			public Vector3 Max => method_11<Vector3>("get_Max", Array.Empty<object>());

			public ItemInfo(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ItemInfo(IntPtr address)
				: this(address, "ItemInfo")
			{
			}

			public bool Contains(Vector2 point, LayoutPlane layoutPlane)
			{
				return method_11<bool>("Contains", new object[2] { point, layoutPlane });
			}
		}

		public Orientation orientation => method_2<Orientation>("orientation");

		public Alignment alignment => method_2<Alignment>("alignment");

		public LayoutPlane layoutPlane => method_2<LayoutPlane>("layoutPlane");

		public float elementSpacing => method_2<float>("elementSpacing");

		public Vector2 padding => method_2<Vector2>("padding");

		public int breadth => method_2<int>("breadth");

		public float itemDragFinishDistance => method_2<float>("itemDragFinishDistance");

		public TiledBackground background => method_3<TiledBackground>("background");

		public float scrollWheelIncrement => method_2<float>("scrollWheelIncrement");

		public GameObject content => method_3<GameObject>("content");

		public int layoutDimension1 => method_2<int>("layoutDimension1");

		public int layoutDimension2 => method_2<int>("layoutDimension2");

		public int layoutDimension3 => method_2<int>("layoutDimension3");

		public float contentSize => method_2<float>("contentSize");

		public float excessContentSize => method_2<float>("excessContentSize");

		public float m_fullListContentSize => method_2<float>("m_fullListContentSize");

		public Vector3 dragBeginContentPosition => method_2<Vector3>("dragBeginContentPosition");

		public Vector3 lastTouchPosition => method_2<Vector3>("lastTouchPosition");

		public float lastContentPosition => method_2<float>("lastContentPosition");

		public bool m_isHoveredOverTouchList => method_2<bool>("m_isHoveredOverTouchList");

		public PegUIElement m_hoveredOverItem => method_3<PegUIElement>("m_hoveredOverItem");

		public bool allowModification => method_2<bool>("allowModification");

		public bool layoutSuspended => method_2<bool>("layoutSuspended");

		public static float ScrollDragThreshold => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "TouchList", "ScrollDragThreshold");

		public static float ItemDragThreshold => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "TouchList", "ItemDragThreshold");

		public static float KineticScrollFriction => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "TouchList", "KineticScrollFriction");

		public static float MinKineticScrollSpeed => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "TouchList", "MinKineticScrollSpeed");

		public static float ScrollBoundsSpringK => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "TouchList", "ScrollBoundsSpringK");

		public static float ScrollBoundsSpringB => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "TouchList", "ScrollBoundsSpringB");

		public static float MinOutOfBoundsDistance => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "TouchList", "MinOutOfBoundsDistance");

		public static float CLIPSIZE_EPSILON => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "TouchList", "CLIPSIZE_EPSILON");

		public int Count => method_11<int>("get_Count", Array.Empty<object>());

		public bool IsReadOnly => method_11<bool>("get_IsReadOnly", Array.Empty<object>());

		public bool IsInitialized => method_11<bool>("get_IsInitialized", Array.Empty<object>());

		public float ScrollValue => method_11<float>("get_ScrollValue", Array.Empty<object>());

		public float ScrollableAmount => method_11<float>("get_ScrollableAmount", Array.Empty<object>());

		public bool CanScrollAhead => method_11<bool>("get_CanScrollAhead", Array.Empty<object>());

		public bool CanScrollBehind => method_11<bool>("get_CanScrollBehind", Array.Empty<object>());

		public float ViewWindowMinValue => method_11<float>("get_ViewWindowMinValue", Array.Empty<object>());

		public float ViewWindowMaxValue => method_11<float>("get_ViewWindowMaxValue", Array.Empty<object>());

		public Vector2 ClipSize => method_11<Vector2>("get_ClipSize", Array.Empty<object>());

		public bool SelectionEnabled => method_11<bool>("get_SelectionEnabled", Array.Empty<object>());

		public int SelectedIndex => method_11<int>("get_SelectedIndex", Array.Empty<object>());

		public bool IsLayoutSuspended => method_11<bool>("get_IsLayoutSuspended", Array.Empty<object>());

		public TouchList(IntPtr address, string className)
			: base(address, className)
		{
		}

		public TouchList(IntPtr address)
			: this(address, "TouchList")
		{
		}

		public void FixUpScrolling()
		{
			method_8("FixUpScrolling");
		}

		public void Clear()
		{
			method_8("Clear");
		}

		public void SetVisibilityOfAllItems()
		{
			method_8("SetVisibilityOfAllItems");
		}

		public bool IsItemVisible(int visualizedListIndex)
		{
			return method_11<bool>("IsItemVisible", new object[1] { visualizedListIndex });
		}

		public void RemoveAt(int index)
		{
			method_9("RemoveAt", new Class276.Enum20[1] { Class276.Enum20.I4 }, index);
		}

		public void RemoveAt(int index, bool repositionItems)
		{
			method_9("RemoveAt", new Class276.Enum20[2]
			{
				Class276.Enum20.I4,
				Class276.Enum20.Boolean
			}, index, repositionItems);
		}

		public void SuspendLayout()
		{
			method_8("SuspendLayout");
		}

		public void ResumeLayout(bool repositionItems)
		{
			method_8("ResumeLayout", repositionItems);
		}

		public void ResetState()
		{
			method_8("ResetState");
		}

		public new void Awake()
		{
			method_8("Awake");
		}

		public new void OnOver(InteractionState oldState)
		{
			method_8("OnOver", oldState);
		}

		public new void OnOut(InteractionState oldState)
		{
			method_8("OnOut", oldState);
		}

		public void OnHover(bool isKnownOver)
		{
			method_8("OnHover", isKnownOver);
		}

		public new void OnPress()
		{
			method_8("OnPress");
		}

		public new void OnRelease()
		{
			method_8("OnRelease");
		}

		public void EnforceInitialized()
		{
			method_8("EnforceInitialized");
		}

		public void Update()
		{
			method_8("Update");
		}

		public void UpdateTouchInput()
		{
			method_8("UpdateTouchInput");
		}

		public void PreBufferLongListItems(bool scrolledAhead)
		{
			method_8("PreBufferLongListItems", scrolledAhead);
		}

		public void UpdateMouseInput()
		{
			method_8("UpdateMouseInput");
		}

		public float GetOutOfBoundsDist(float contentPosition)
		{
			return method_11<float>("GetOutOfBoundsDist", new object[1] { contentPosition });
		}

		public void OnScrolled()
		{
			method_8("OnScrolled");
		}

		public Vector3 GetTouchPosition()
		{
			return method_11<Vector3>("GetTouchPosition", Array.Empty<object>());
		}

		public float GetItemDragDelta(Vector3 touchPosition)
		{
			return method_11<float>("GetItemDragDelta", new object[1] { touchPosition });
		}

		public void LoadAhead()
		{
			method_8("LoadAhead");
		}

		public void LoadBehind()
		{
			method_8("LoadBehind");
		}

		public int GetNumItemsBehindView()
		{
			return method_11<int>("GetNumItemsBehindView", Array.Empty<object>());
		}

		public int GetNumItemsAheadOfView()
		{
			return method_11<int>("GetNumItemsAheadOfView", Array.Empty<object>());
		}

		public void RefreshList(int startingLongListIndex, bool preserveScrolling)
		{
			method_8("RefreshList", startingLongListIndex, preserveScrolling);
		}

		public void OnScrollingEnabledChanged()
		{
			method_8("OnScrollingEnabledChanged");
		}

		public void RecalculateSize()
		{
			method_8("RecalculateSize");
		}

		public bool RecalculateLongListContentSize(bool fireOnScroll)
		{
			return method_11<bool>("RecalculateLongListContentSize", new object[1] { fireOnScroll });
		}

		public void UpdateBackgroundBounds()
		{
			method_8("UpdateBackgroundBounds");
		}

		public void UpdateBackgroundScroll()
		{
			method_8("UpdateBackgroundScroll");
		}

		public float GetBreadthPosition(int itemIndex)
		{
			return method_11<float>("GetBreadthPosition", new object[1] { itemIndex });
		}

		public Vector3 GetNegatedScale(Vector3 scale)
		{
			return method_11<Vector3>("GetNegatedScale", new object[1] { scale });
		}

		public int GetVector2Dimension(int vec3Dimension)
		{
			return method_11<int>("GetVector2Dimension", new object[1] { vec3Dimension });
		}

		public int GetVector3Dimension(int vec2Dimension)
		{
			return method_11<int>("GetVector3Dimension", new object[1] { vec2Dimension });
		}

		public void ValidateBreadth()
		{
			method_8("ValidateBreadth");
		}

		public Bounds CalculateLocalClipBounds()
		{
			return method_11<Bounds>("CalculateLocalClipBounds", Array.Empty<object>());
		}
	}
}
